Newt_Population_Manager Class Reference

The class to handle all newt population related matters. More...

#include <Newt_Population_Manager.h>

Inheritance diagram for Newt_Population_Manager:

Public Member Functions
	Newt_Population_Manager (Landscape *L)
	Newt_Population_Manager Constructor. More...
virtual	~Newt_Population_Manager (void)
	Newt_Population_Manager Destructor. More...
void	CreateObjects (int ob_type, TAnimal *pvo, struct_Newt *data, int number)
	Method for creating a new individual Newt. More...
int	IsBreedingSeason ()
	Returns whether it is breeding season or not. More...
void	SetFreeLivingMortChance ()
	Calculate the daily background mortality chance based on weather. More...
double	GetEggDDRateTransformation (double a_temperature)
	Returns the value from the precalulated m_NewtEgg_DDTempRate to get effective day degrees. More...
virtual void	TheAOROutputProbe ()
	Special output functionality. More...
void	RecordAdultProduction (int a_adult)
	Add a new adult to the stats record. More...
void	RecordEggProduction (int a_eggs)
	Add a new egg production to the stats record. More...
void	RecordMetamorphosis (int a_age)
	Add a new metamorphosis time to the stats record. More...
void	InitOutputMetamorphosisStats ()
	Initialises output mean and variance for meatamorphosis times this year. More...
void	OutputMetamorphosisStats ()
	Output mean and variance for meatamorphosis times this year. More...
Public Member Functions inherited from Population_Manager
	Population_Manager (Landscape *L)
virtual	~Population_Manager (void)
void	SetNoProbes (int a_pn)
unsigned	GetLiveArraySize (int a_listindex)
	Gets the number of 'live' objects for a list index in the TheArray. More...
void	IncLiveArraySize (int a_listindex)
	Increments the number of 'live' objects for a list index in the TheArray. More...
virtual void	Catastrophe (int)
unsigned int	FarmAnimalCensus (unsigned int a_farm, unsigned int a_typeofanimal)
char *	SpeciesSpecificReporting (int a_species, int a_time)
char *	ProbeReport (int a_time)
char *	ProbeReportTimed (int a_time)
void	ImpactProbeReport (int a_Time)
bool	BeginningOfMonth ()
void	LOG (const char *fname)
int	SupplyStepSize ()
int	SupplySimW ()
int	SupplySimH ()
virtual void	Run (int NoTSteps)
virtual float	Probe (int ListIndex, probe_data *p_TheProbe)
virtual void	ImpactedProbe ()
int	SupplyListNameLength ()
TAnimal *	SupplyAnimalPtr (int a_index, int a_animal)
	Returns the pointer indexed by a_index and a_animal. Note NO RANGE CHECK. More...
unsigned	SupplyListIndexSize ()
unsigned	SupplyListSize (unsigned listindex)
bool	CheckXY (int l, int i)
	Debug method to test for out of bounds coordinates. More...
const char *	SupplyListName (int i)
bool	IsLast (unsigned listindex)
int	SupplyState (unsigned listindex, unsigned j)
virtual void	SupplyLocXY (unsigned listindex, unsigned j, int &x, int &y)
const char *	SupplyStateNames (int i)
unsigned	SupplyStateNamesLength ()
virtual void	DisplayLocations ()
int	ProbeFileInput (char *p_Filename, int p_ProbeNo)
TAnimal *	FindClosest (int x, int y, unsigned Type)
bool	OpenTheRipleysOutputProbe (string a_NWordFilename)
void	OpenTheAOROutputProbe (string a_AORFilename)
bool	OpenTheMonthlyRipleysOutputProbe ()
bool	OpenTheReallyBigProbe ()
virtual void	TheRipleysOutputProbe (FILE *a_prb)
virtual void	TheReallyBigOutputProbe ()
void	CloseTheMonthlyRipleysOutputProbe ()
virtual void	CloseTheRipleysOutputProbe ()
virtual void	CloseTheReallyBigOutputProbe ()
TTypesOfPopulation	GetPopulationType ()
int	GetSeasonNumber ()
	Get the season number. More...
void	LamdaDeath (int x, int y)
void	LamdaBirth (int x, int y)
void	LamdaBirth (int x, int y, int z)
void	LamdaClear ()
void	LamdaDumpOutput ()
virtual int	SupplyPegPosx (int)
virtual int	SupplyPegPosy (int)
virtual int	SupplyCovPosx (int)
virtual int	SupplyCovPosy (int)
virtual bool	OpenTheFledgelingProbe ()
virtual bool	OpenTheBreedingPairsProbe ()
virtual bool	OpenTheBreedingSuccessProbe ()
virtual void	BreedingPairsOutput (int)
virtual int	TheBreedingFemalesProbe (int)
virtual int	TheFledgelingProbe ()
virtual void	BreedingSuccessProbeOutput (double, int, int, int, int, int, int, int)
virtual int	TheBreedingSuccessProbe (int &, int &, int &, int &, int &, int &)
virtual void	FledgelingProbeOutput (int, int)
virtual void	TheGeneticProbe (unsigned, int, unsigned &)
virtual void	GeneticsResultsOutput (FILE *, unsigned)

Protected Member Functions
virtual void	DoFirst ()
	Things to do before anything else at the start of a timestep More...
void	SetUnsetBreedingSeason ()
	Controls when it is breeding season More...
Protected Member Functions inherited from Population_Manager
virtual bool	StepFinished ()
	Overrides the population manager StepFinished - there is no chance that hunters do not finish a step behaviour. More...
virtual void	DoBefore ()
virtual void	DoAfter ()
virtual void	DoAlmostLast ()
virtual void	DoLast ()
void	EmptyTheArray ()
	Removes all objects from the TheArray by deleting them and clearing TheArray. More...
void	SortX (unsigned Type)
void	SortXIndex (unsigned Type)
void	SortY (unsigned Type)
void	SortState (unsigned Type)
void	SortStateR (unsigned Type)
unsigned	PartitionLiveDead (unsigned Type)
void	Shuffle_or_Sort (unsigned Type)
void	Shuffle (unsigned Type)
virtual void	Catastrophe ()

Protected Attributes
int	m_BreedingSeasonFlag
	Set to 0 when it is newt breeding season, then records the number of days after. More...
double	m_NewtEgg_DDTempRate [31]
	An array to hold a precalulated day-degree rate transformation for egg development. More...
SimpleStatistics	m_NewtMetamorphosisStats
	A class for holding the stats on newt metamorphosis development times. More...
SimpleStatistics	m_NewtEggProdStats
	A class for holding the stats on newt egg production. More...
SimpleStatistics	m_NewtAdultProdStats
	A class for holding the stats on newt adult production. More...
Protected Attributes inherited from Population_Manager
vector< unsigned >	m_LiveArraySize
int	m_NoProbes
AOR_Probe *	m_AOR_Probe
FILE *	m_GeneticsFile
FILE *	m_AlleleFreqsFile
FILE *	m_EasyPopRes
const char *	StateNames [100]
int	m_catastrophestartyear
int	m_StepSize
vector< TListOfAnimals >	TheArray
unsigned	StateNamesLength
const char *	m_ListNames [32]
unsigned	m_ListNameLength
FILE *	TestFile
FILE *	TestFile2
unsigned	BeforeStepActions [12]
int	m_SeasonNumber
	Holds the season number. Used when running goose and hunter sims. More...
TTypesOfPopulation	m_population_type
ofstream *	AOROutputPrb
FILE *	RipleysOutputPrb
FILE *	RipleysOutputPrb1
FILE *	RipleysOutputPrb2
FILE *	RipleysOutputPrb3
FILE *	RipleysOutputPrb4
FILE *	RipleysOutputPrb5
FILE *	RipleysOutputPrb6
FILE *	RipleysOutputPrb7
FILE *	RipleysOutputPrb8
FILE *	RipleysOutputPrb9
FILE *	RipleysOutputPrb10
FILE *	RipleysOutputPrb11
FILE *	RipleysOutputPrb12
FILE *	ReallyBigOutputPrb
long int	lamdagrid [2][257][257]

Additional Inherited Members
Public Attributes inherited from Population_Manager
int	IndexArrayX [5][10000]
probe_data *	TheProbe [100]
int	SimH
int	SimW
unsigned	SimHH
unsigned	SimWH
char	m_SimulationName [255]
bool	ProbesSet
Landscape *	m_TheLandscape

Detailed Description

The class to handle all newt population related matters.

Constructor & Destructor Documentation

Newt_Population_Manager()

Newt_Population_Manager::Newt_Population_Manager

(

Landscape *

L

)

Newt_Population_Manager Constructor.

This class takes care of newt object creation and any list management methods. This is handled by In addition the newt population managner must control the breeding season flag, done in SetUnsetBreedingSeason

                                                             : Population_Manager(L) {
    // Load List of Animal Classes
    m_ListNames[0] = "Newt_Egg";
    m_ListNames[1] = "Newt_Larva";
    m_ListNames[2] = "Newt_Juvenile";
    m_ListNames[3] = "Newt_Male";
    m_ListNames[4] = "Newt_Female";
    m_ListNameLength = 5;
    // We need one vector for each life stage
    for (unsigned int i = 0; i < (10 - m_ListNameLength); i++) {
        TheArray.pop_back();
    }
    strcpy(m_SimulationName, "Newt Simulation");
    // Assign the correct values to static variables
    Newt_Base::m_test_pesticide_egg = cfg_Newt_Test_Pesticide_Egg.value();
    Newt_Base::m_test_pesticide_larva = cfg_Newt_Test_Pesticide_Larva.value();
    Newt_Base::m_test_pesticide_terrestrial = cfg_Newt_Test_Pesticide_Terrestrial.value();
    Newt_Egg::m_EggPPPThreshold = cfg_NewtEggPPPToxTrigger.value();
    Newt_Egg::m_EggPPPElimRate = cfg_NewtEggPPPToxEliminationRate.value();
    Newt_Egg::m_EggPPPEffectProbability = cfg_NewtEggPPPEffectProbability.value();
    Newt_Larva::m_LarvaPPPThreshold = cfg_NewtLarvaPPPToxTrigger.value();
    Newt_Larva::m_LarvaPPPElimRate = cfg_NewtLarvaPPPToxEliminationRate.value();
    Newt_Larva::m_LarvaPPPEffectProbability = cfg_NewtLarvaPPPEffectProbability.value();
    Newt_Juvenile::m_JuvenilePPPThreshold_EnvConc = cfg_NewtJuvenilePPPToxTrigger_EnvConc.value();
    Newt_Juvenile::m_JuvenilePPPThreshold_Overspray = cfg_NewtJuvenilePPPToxTrigger_Overspray.value();
    if (Newt_Juvenile::m_JuvenilePPPThreshold_Overspray<Newt_Juvenile::m_JuvenilePPPThreshold_EnvConc) Newt_Juvenile::m_JuvenilePPPThreshold_Min = Newt_Juvenile::m_JuvenilePPPThreshold_Overspray;
        else Newt_Juvenile::m_JuvenilePPPThreshold_Min = Newt_Juvenile::m_JuvenilePPPThreshold_EnvConc;
    Newt_Juvenile::m_JuvenilePPPElimRate = cfg_NewtJuvenilePPPToxEliminationRate.value();
    Newt_Juvenile::m_JuvenilePPPEffectProbability_EnvConc = cfg_NewtJuvenilePPPEffectProbability_EnvConc.value();
    Newt_Juvenile::m_JuvenilePPPEffectProbability_Overspray = cfg_NewtJuvenilePPPEffectProbability_Overspray.value();
    Newt_Adult::m_AdultPPPThreshold = cfg_NewtAdultPPPToxTrigger.value();
    Newt_Adult::m_AdultPPPElimRate = cfg_NewtAdultPPPToxEliminationRate.value();
    Newt_Adult::m_AdultPPPEffectProbability = cfg_NewtAdultPPPEffectProbability.value();
    Newt_Base::m_EggDevelopmentDDTotal = cfg_NewtEggDevelTotal.value();
    Newt_Base::m_EggDevelopmentDDParameter = cfg_NewtEggDevelDDParameter.value();
    Newt_Base::m_JuvenileDevelopmentSize = cfg_NewtJuvenileDevelSize.value();
    Newt_Base::m_EggMortalityChance = cfg_NewtEggMortalityChance.value();
    Newt_Larva::m_LarvaDevelopmentUpperSz = cfg_NewtLarvaDevelThresholdUpperSz.value();
    Newt_Larva::m_LarvaDevelopmentLowerSz = cfg_NewtLarvaDevelThresholdLowerSz.value();
    Newt_Larva::m_LarvaDevelopmentTime = cfg_NewtLarvaDevelThresholdTime.value();
    Newt_Larva::m_LarvaMortalityChance = cfg_NewtLarvaMortalityChance.value();
    Newt_Larva::m_LarvalFoodProportion = cfg_LarvalFoodProportion.value();
    Newt_Larva::m_NewtLarvaDailyGrowthIncrement = cfg_NewtLarvaDailyGrowthIncrement.value();
    Newt_Juvenile::m_JuvenileDailyWeightGain = cfg_NewtJuvenileDailyLengthGain.value();
    Newt_Juvenile::m_SimW = m_TheLandscape->SupplySimAreaWidth();
    Newt_Juvenile::m_SimH = m_TheLandscape->SupplySimAreaHeight();
    Newt_Juvenile::m_roadmortalityprob = cfg_NewtRoadMortalityProb.value();
    Newt_Juvenile::m_newtwalkspeed = cfg_NewtWalkSpeed.value();
    Newt_Juvenile::m_newtwalkstepsize = cfg_NewtWalkStepsize.value();
    Newt_Adult::m_newtadultwalkspeed = cfg_NewtWalkSpeed.value() / 10; // 1/ 10th of the juvenile following Karlsson et al( 2007 )
    Newt_Juvenile::m_goodhabitatdispersalprob = cfg_newtgoodhabitatdispersalprob.value();
    Newt_Juvenile::m_poorhabitatdispersalprob = cfg_newtpoorhabitatdispersalprob.value();
    Newt_Juvenile::m_NewtDormancyTemperature = cfg_newtdormancytemp.value();
    Newt_Juvenile::m_NewtDormancyHumidity = cfg_newtdormancyhumidity.value();
    Newt_Female::m_eggproductionvolume = cfg_newteggproductionvolume.value();
    Newt_Female::m_eggdailyproductionvolume = cfg_newtdailyeggproductionvolume.value();
    // Create any precalculated data arrays
    for (int i = 1; i < 30; i++) {
        double a = cfg_NewtEggDevelTotal.value() * pow(i, cfg_NewtEggDevelDDParameter.value());
        double b = a / double(i);
        m_NewtEgg_DDTempRate[i] = (cfg_NewtEggDevelTotal.value() / b) / double(i);
    }
    m_NewtEgg_DDTempRate[0] = 0.0;
    m_NewtEgg_DDTempRate[30] = 0.0;
    // Create some animals
    struct_Newt* sp;
    sp = new struct_Newt;
    sp->NPM = this;
    sp->L = m_TheLandscape;
    sp->age = 365;
    sp->reproinhib = false;
    for (int i = 0; i < cfg_newt_startnumber.value(); i++) {
        int pref = m_TheLandscape->SupplyRandomPondRef();
        sp->x = m_TheLandscape->SupplyCentroidX(pref);
        sp->y = m_TheLandscape->SupplyCentroidY(pref);
        if (m_TheLandscape->SupplyElementType(sp->x, sp->y) != tole_Pond) {
            g_msg->Warn("Centroid not in Pond.Pond ref : ", pref);
            exit(0);
        }
        sp->pondrefs.resize(1);
        sp->pondrefs[0] = m_TheLandscape->SupplyPondIndex(pref);
        // test if this is a pond, if so create a male and female
        CreateObjects(tton_Male, NULL, sp, 1);
        CreateObjects(tton_Female, NULL, sp, 1);
    }
    // Now we must the set the in pond flag for all newly created newts (because we put them in a pond)
    int sz = int( GetLiveArraySize( tton_Male ) );
    for (int i = 0; i < sz; i++) {
        dynamic_cast<Newt_Male*>(TheArray[tton_Male][i])->SetInPond();
    }
    sz = int( GetLiveArraySize( tton_Female ) );
    for (int i = 0; i < sz; i++) {
        dynamic_cast<Newt_Female*>(TheArray[tton_Female][i])->SetInPond();
    }
    // Set any variable values that are needed on start-up
    m_BreedingSeasonFlag = 1;
    // Set up any output needed
#ifdef __RECORDNEWTMETAMORPHOSIS
    InitOutputMetamorphosisStats();
#endif
    if (cfg_RipleysOutput_used.value()) {
        OpenTheRipleysOutputProbe("");
    }
    if (cfg_ReallyBigOutput_used.value()) {
        OpenTheReallyBigProbe();
    }
    else ReallyBigOutputPrb = 0;
}

References struct_Newt::age, cfg_LarvalFoodProportion, cfg_newt_startnumber, cfg_Newt_Test_Pesticide_Egg, cfg_Newt_Test_Pesticide_Larva, cfg_Newt_Test_Pesticide_Terrestrial, cfg_NewtAdultPPPEffectProbability, cfg_NewtAdultPPPToxEliminationRate, cfg_NewtAdultPPPToxTrigger, cfg_newtdailyeggproductionvolume, cfg_newtdormancyhumidity, cfg_newtdormancytemp, cfg_NewtEggDevelDDParameter, cfg_NewtEggDevelTotal, cfg_NewtEggMortalityChance, cfg_NewtEggPPPEffectProbability, cfg_NewtEggPPPToxEliminationRate, cfg_NewtEggPPPToxTrigger, cfg_newteggproductionvolume, cfg_newtgoodhabitatdispersalprob, cfg_NewtJuvenileDailyLengthGain, cfg_NewtJuvenileDevelSize, cfg_NewtJuvenilePPPEffectProbability_EnvConc, cfg_NewtJuvenilePPPEffectProbability_Overspray, cfg_NewtJuvenilePPPToxEliminationRate, cfg_NewtJuvenilePPPToxTrigger_EnvConc, cfg_NewtJuvenilePPPToxTrigger_Overspray, cfg_NewtLarvaDailyGrowthIncrement, cfg_NewtLarvaDevelThresholdLowerSz, cfg_NewtLarvaDevelThresholdTime, cfg_NewtLarvaDevelThresholdUpperSz, cfg_NewtLarvaMortalityChance, cfg_NewtLarvaPPPEffectProbability, cfg_NewtLarvaPPPToxEliminationRate, cfg_NewtLarvaPPPToxTrigger, cfg_newtpoorhabitatdispersalprob, cfg_NewtRoadMortalityProb, cfg_NewtWalkSpeed, cfg_NewtWalkStepsize, cfg_ReallyBigOutput_used, cfg_RipleysOutput_used, CreateObjects(), g_msg, Population_Manager::GetLiveArraySize(), InitOutputMetamorphosisStats(), struct_Newt::L, Newt_Adult::m_AdultPPPEffectProbability, Newt_Adult::m_AdultPPPElimRate, Newt_Adult::m_AdultPPPThreshold, m_BreedingSeasonFlag, Newt_Female::m_eggdailyproductionvolume, Newt_Base::m_EggDevelopmentDDParameter, Newt_Base::m_EggDevelopmentDDTotal, Newt_Base::m_EggMortalityChance, Newt_Egg::m_EggPPPEffectProbability, Newt_Egg::m_EggPPPElimRate, Newt_Egg::m_EggPPPThreshold, Newt_Female::m_eggproductionvolume, Newt_Juvenile::m_goodhabitatdispersalprob, Newt_Juvenile::m_JuvenileDailyWeightGain, Newt_Base::m_JuvenileDevelopmentSize, Newt_Juvenile::m_JuvenilePPPEffectProbability_EnvConc, Newt_Juvenile::m_JuvenilePPPEffectProbability_Overspray, Newt_Juvenile::m_JuvenilePPPElimRate, Newt_Juvenile::m_JuvenilePPPThreshold_EnvConc, Newt_Juvenile::m_JuvenilePPPThreshold_Min, Newt_Juvenile::m_JuvenilePPPThreshold_Overspray, Newt_Larva::m_LarvaDevelopmentLowerSz, Newt_Larva::m_LarvaDevelopmentTime, Newt_Larva::m_LarvaDevelopmentUpperSz, Newt_Larva::m_LarvalFoodProportion, Newt_Larva::m_LarvaMortalityChance, Newt_Larva::m_LarvaPPPEffectProbability, Newt_Larva::m_LarvaPPPElimRate, Newt_Larva::m_LarvaPPPThreshold, Population_Manager::m_ListNameLength, Population_Manager::m_ListNames, Newt_Adult::m_newtadultwalkspeed, Newt_Juvenile::m_NewtDormancyHumidity, Newt_Juvenile::m_NewtDormancyTemperature, m_NewtEgg_DDTempRate, Newt_Larva::m_NewtLarvaDailyGrowthIncrement, Newt_Juvenile::m_newtwalkspeed, Newt_Juvenile::m_newtwalkstepsize, Newt_Juvenile::m_poorhabitatdispersalprob, Newt_Juvenile::m_roadmortalityprob, Newt_Juvenile::m_SimH, Population_Manager::m_SimulationName, Newt_Juvenile::m_SimW, Newt_Base::m_test_pesticide_egg, Newt_Base::m_test_pesticide_larva, Newt_Base::m_test_pesticide_terrestrial, Population_Manager::m_TheLandscape, struct_Newt::NPM, Population_Manager::OpenTheReallyBigProbe(), Population_Manager::OpenTheRipleysOutputProbe(), struct_Newt::pondrefs, Population_Manager::ReallyBigOutputPrb, struct_Newt::reproinhib, Landscape::SupplyCentroidX(), Landscape::SupplyCentroidY(), Landscape::SupplyElementType(), Landscape::SupplyPondIndex(), Landscape::SupplyRandomPondRef(), Landscape::SupplySimAreaHeight(), Landscape::SupplySimAreaWidth(), Population_Manager::TheArray, tole_Pond, tton_Female, tton_Male, CfgInt::value(), CfgFloat::value(), CfgBool::value(), MapErrorMsg::Warn(), struct_Newt::x, and struct_Newt::y.

~Newt_Population_Manager()

Newt_Population_Manager::~Newt_Population_Manager ( void  )

virtual

Newt_Population_Manager Destructor.

                                                      {
    // Should all be done by the Population_Manager destructor
}

Member Function Documentation

CreateObjects()

void Newt_Population_Manager::CreateObjects	(	int	ob_type,
		TAnimal *	pvo,
		struct_Newt *	data,
		int	number
	)

Method for creating a new individual Newt.

                                                                                                  {
    Newt_Egg*  new_Newt_Egg;
    Newt_Larva*  new_Newt_Larva;
    Newt_Juvenile*  new_Newt_Juvenile;
    Newt_Male* new_Newt_Male;
    Newt_Female*  new_Newt_Female;
#ifdef __RECORDNEWTMETAMORPHOSIS
    if (ob_type == tton_Egg) RecordEggProduction(number);
#endif
    for (int i = 0; i < number; i++) {
        switch (ob_type) {
        case tton_Egg:
            if (unsigned(TheArray[ob_type].size())>GetLiveArraySize(ob_type)) {
                // We need to reuse an object
                dynamic_cast<Newt_Egg*>(TheArray[ob_type][GetLiveArraySize(ob_type)])->ReInit(data->x, data->y, data->pondrefs, data->L, data->NPM, false);
                IncLiveArraySize(ob_type);
            }
            else {
                new_Newt_Egg = new Newt_Egg(data->x, data->y, data->pondrefs, data->L, data->NPM, false);
                TheArray[ob_type].push_back(new_Newt_Egg);
                IncLiveArraySize(ob_type);
            }
            break;
        case tton_Larva:
            if (unsigned(TheArray[ob_type].size()) > GetLiveArraySize(ob_type)) {
                // We need to reuse an object
                new_Newt_Larva = dynamic_cast<Newt_Larva*>(TheArray[ob_type][GetLiveArraySize(ob_type)]);
                new_Newt_Larva->ReInit(data->x, data->y, data->pondrefs, data->L, data->NPM, data->age, data->reproinhib);
                new_Newt_Larva->SetAge(data->age);
            }
            else {
                new_Newt_Larva = new Newt_Larva(data->x, data->y, data->pondrefs, data->L, data->NPM, data->age, data->reproinhib);
                TheArray[ob_type].push_back(new_Newt_Larva);
                new_Newt_Larva->SetAge(data->age);
            }
            IncLiveArraySize(ob_type);
            break;
        case tton_Juvenile:
            if (unsigned(TheArray[ob_type].size()) > GetLiveArraySize(ob_type)) {
                // We need to reuse an object
                new_Newt_Juvenile = dynamic_cast<Newt_Juvenile*>(TheArray[ob_type][GetLiveArraySize(ob_type)]);
                new_Newt_Juvenile->ReInit(data->x, data->y, data->pondrefs, data->L, data->NPM, data->age, data->reproinhib);
                new_Newt_Juvenile->SetAge(data->age);
            }
            else {
                new_Newt_Juvenile = new Newt_Juvenile(data->x, data->y, data->pondrefs, data->L, data->NPM, data->age, data->reproinhib);
                new_Newt_Juvenile->SetAge(data->age);
                TheArray[ob_type].push_back(new_Newt_Juvenile);
            }
            IncLiveArraySize(ob_type);
            break;
        case tton_Male:
            if (unsigned(TheArray[ob_type].size()) > GetLiveArraySize(ob_type)) {
                // We need to reuse an object
                new_Newt_Male = dynamic_cast<Newt_Male*>(TheArray[ob_type][GetLiveArraySize(ob_type)]);
                new_Newt_Male->ReInit(data->x, data->y, data->pondrefs, data->L, data->NPM, data->age, data->reproinhib);
                new_Newt_Male->SetAge(data->age);
                new_Newt_Male->SetWeight(data->weight);
            }
            else {
                new_Newt_Male = new Newt_Male(data->x, data->y, data->pondrefs, data->L, data->NPM, data->age, data->reproinhib);
                new_Newt_Male->SetAge(data->age);
                new_Newt_Male->SetWeight(data->weight);
                TheArray[ob_type].push_back(new_Newt_Male);
            }
            IncLiveArraySize(ob_type);
            break;
        case tton_Female:
            if (unsigned(TheArray[ob_type].size()) > GetLiveArraySize(ob_type)) {
                // We need to reuse an object
                new_Newt_Female = dynamic_cast<Newt_Female*>(TheArray[ob_type][GetLiveArraySize(ob_type)]);
                new_Newt_Female->ReInit(data->x, data->y, data->pondrefs, data->L, data->NPM, data->age, data->reproinhib);
                new_Newt_Female->SetAge(data->age);
                new_Newt_Female->SetWeight(data->weight);
            }
            else {
                new_Newt_Female = new Newt_Female(data->x, data->y, data->pondrefs, data->L, data->NPM, data->age, data->reproinhib);
                new_Newt_Female->SetAge(data->age);
                new_Newt_Female->SetWeight(data->weight);
                TheArray[ob_type].push_back(new_Newt_Female);
            }
            IncLiveArraySize(ob_type);
            break;
        }
    }
}

References struct_Newt::age, Population_Manager::GetLiveArraySize(), Population_Manager::IncLiveArraySize(), struct_Newt::L, struct_Newt::NPM, struct_Newt::pondrefs, RecordEggProduction(), Newt_Larva::ReInit(), Newt_Juvenile::ReInit(), Newt_Male::ReInit(), Newt_Female::ReInit(), struct_Newt::reproinhib, Newt_Base::SetAge(), Newt_Juvenile::SetWeight(), Population_Manager::TheArray, tton_Egg, tton_Female, tton_Juvenile, tton_Larva, tton_Male, struct_Newt::weight, struct_Newt::x, and struct_Newt::y.

Referenced by Newt_Population_Manager(), Newt_Female::st_Breed(), Newt_Egg::st_NextStage(), Newt_Larva::st_NextStage(), and Newt_Juvenile::st_NextStage().

DoFirst()

void Newt_Population_Manager::DoFirst ( void  )

protectedvirtual

Things to do before anything else at the start of a timestep

Reimplemented from Population_Manager.

                                      {
    int today = m_TheLandscape->SupplyDayInYear();
    if (today == cfg_breedingseasonstart.value()) m_BreedingSeasonFlag = 0;
    else if (today >= cfg_breedingseasonend.value()) m_BreedingSeasonFlag++;
    if (today == 1) {
        int sz = int( GetLiveArraySize( tton_Female ) );
        for (int i = 0; i < sz; i++) {
            dynamic_cast<Newt_Female*>(TheArray[tton_Female][i])->ResetEggProduction();
        }
    }
    SetFreeLivingMortChance();
#ifdef __RECORDNEWTMETAMORPHOSIS
    if (today == 364) {
        OutputMetamorphosisStats();
    }
#endif
}

References cfg_breedingseasonend, cfg_breedingseasonstart, Population_Manager::GetLiveArraySize(), m_BreedingSeasonFlag, Population_Manager::m_TheLandscape, OutputMetamorphosisStats(), SetFreeLivingMortChance(), Landscape::SupplyDayInYear(), Population_Manager::TheArray, tton_Female, and CfgInt::value().

GetEggDDRateTransformation()

double Newt_Population_Manager::GetEggDDRateTransformation ( double  a_temperature )

inline

Returns the value from the precalulated m_NewtEgg_DDTempRate to get effective day degrees.

Uses the precalulated m_NewtEgg_DDTempRate array for speed optimisation. Rounds to the nearest degree.

                                                           {
       int temp = int(round(a_temperature));
       if (temp <= 1) return 0.0;
       if (temp > 29) return 0.0;
       return m_NewtEgg_DDTempRate[temp]*a_temperature;
   }

References m_NewtEgg_DDTempRate.

Referenced by Newt_Egg::st_Develop().

InitOutputMetamorphosisStats()

void Newt_Population_Manager::InitOutputMetamorphosisStats

(

)

Initialises output mean and variance for meatamorphosis times this year.

                                                           {
    fstream ofile("NewtMetamorphosisDevelStats.txt", ios::out);
    ofile << "Year" << '\t' << "N" << '\t' << "Mean" << '\t' << "Variance" << '\t' << "EggProduction" << '\t' << "JuvenileProduction" << '\t' << "AdultProduction" << '\t' << "Juveniles" << '\t' << "Adults" << endl;
    ofile.close();
}

Referenced by Newt_Population_Manager().

IsBreedingSeason()

int Newt_Population_Manager::IsBreedingSeason ( )

inline

Returns whether it is breeding season or not.

                          {
       return m_BreedingSeasonFlag;
   }

References m_BreedingSeasonFlag.

Referenced by Newt_Female::st_Breed(), Newt_Adult::st_EvaluateHabitat(), and Newt_Female::st_EvaluateHabitat().

OutputMetamorphosisStats()

void Newt_Population_Manager::OutputMetamorphosisStats

(

)

Output mean and variance for meatamorphosis times this year.

                                                       {
    fstream ofile("NewtMetamorphosisDevelStats.txt", ios::app | ios::out);
    ofile << m_TheLandscape->SupplyYearNumber() << '\t' << m_NewtMetamorphosisStats.get_N() << '\t' << m_NewtMetamorphosisStats.get_meanvalue() << '\t' << m_NewtMetamorphosisStats.get_varianceP()
        << '\t' << m_NewtEggProdStats.get_Total() << '\t' << m_NewtMetamorphosisStats.get_N() << '\t' << m_NewtAdultProdStats.get_N() << '\t' << GetLiveArraySize( tton_Juvenile ) << '\t' << GetLiveArraySize( tton_Female ) + GetLiveArraySize( tton_Male ) << endl;
    m_NewtMetamorphosisStats.ClearData();
    m_NewtEggProdStats.ClearData();
    m_NewtAdultProdStats.ClearData();
    ofile.close();
}

References SimpleStatistics::ClearData(), SimpleStatistics::get_meanvalue(), SimpleStatistics::get_N(), SimpleStatistics::get_Total(), SimpleStatistics::get_varianceP(), Population_Manager::GetLiveArraySize(), m_NewtAdultProdStats, m_NewtEggProdStats, m_NewtMetamorphosisStats, Population_Manager::m_TheLandscape, Landscape::SupplyYearNumber(), tton_Female, tton_Juvenile, and tton_Male.

Referenced by DoFirst().

RecordAdultProduction()

void Newt_Population_Manager::RecordAdultProduction

(

int

a_adult

)

Add a new adult to the stats record.

                                                               {
    // A Newt has become juvenile, we need to record this for the statistics
    m_NewtAdultProdStats.add_variable(a_adult);
}

References SimpleStatistics::add_variable(), and m_NewtAdultProdStats.

Referenced by Newt_Adult::Init().

RecordEggProduction()

void Newt_Population_Manager::RecordEggProduction

(

int

a_eggs

)

Add a new egg production to the stats record.

                                                            {
    // A Newt has become juvenile, we need to record this for the statistics
    m_NewtEggProdStats.add_variable(a_eggs);
}

References SimpleStatistics::add_variable(), and m_NewtEggProdStats.

Referenced by CreateObjects().

RecordMetamorphosis()

void Newt_Population_Manager::RecordMetamorphosis

(

int

a_age

)

Add a new metamorphosis time to the stats record.

                                                           {
    // A Newt has become juvenile, we need to record this for the statistics
    m_NewtMetamorphosisStats.add_variable(a_age);
}

References SimpleStatistics::add_variable(), and m_NewtMetamorphosisStats.

Referenced by Newt_Larva::st_NextStage().

SetFreeLivingMortChance()

void Newt_Population_Manager::SetFreeLivingMortChance

(

)

Calculate the daily background mortality chance based on weather.

The model for daily newt mortality in free-living stages and out of water is based on Griffiths et al (2010). It assumes survival is inversely releated to rainfall Jun-Feb and minimum winter mean (Dec-Feb). This method calculates the daily probability of survival assuming 270 days of season and 0.0016 reduction for each 1mm rain above 200mm and 0.1 reduction for each 1 degree above -2 during the 90 days of Winter assumed by Griffiths et al (2010). The two survival curves are added and divided by 2 (equal weight and central tendency). Because we use seasonal data we only need to calculate this at the beginning of the season. Initial tests show that extending these relationships outside the range of the original data leads to extreme mortalities and therefore input data is constrained to lie within the maximum bounds of the original data used for the relationships. This daily rate of mortality is applied each day so the overall survival rate per year is transformed to daily probability needed to achieve this.

                                                      {
    double survivalchance1 = 0;
    double survivalchance2 = 0;
    int today = m_TheLandscape->SupplyDayInYear();
    if (today == June) {
        // New season, so calculate the mortalities
        double mortrainfall = m_TheLandscape->SupplyRainPeriod(g_date->OldDays() + June + 270, 270);
        if (mortrainfall < 200) mortrainfall = 200;
        if (mortrainfall > 650) mortrainfall = 650;
        double morttemp = m_TheLandscape->SupplyTempPeriod(g_date->OldDays() + December + 90, 90) / 90.0;
        if (morttemp < -2.0) morttemp = -2.0;
        if (morttemp > 4.0) morttemp = 4.0;
        survivalchance1 = pow((1.0 - ((mortrainfall - 200)*cfg_NewtNARMortalityFactor.value())), 1.0 / 365.0);
        survivalchance2 = pow((1.0 - ((morttemp + 2.0)*cfg_NewtWTMortalityFactor.value())), 1.0 / 365.0);
        // Griffiths et al have an average survival of 0.5, which equates to a mortality of 0.001897 per day.
        // However, tests indicate that this is just too low for overall population persistance.
        double mortchance = 1.0 - (((survivalchance1 + survivalchance2) / 2.0) );
        // Add some annual stochasiticity
        mortchance = mortchance + (mortchance*g_rand_uni()*2.0) - (mortchance*1.0); // +/-10%   
        Newt_Base::m_JuvenileMortalityChance = mortchance + 0.001;
        Newt_Base::m_AdultMortalityChance = mortchance;
    }
}

References cfg_NewtNARMortalityFactor, cfg_NewtWTMortalityFactor, December, g_date, g_rand_uni, June, Newt_Base::m_AdultMortalityChance, Newt_Base::m_JuvenileMortalityChance, Population_Manager::m_TheLandscape, Calendar::OldDays(), Landscape::SupplyDayInYear(), Landscape::SupplyRainPeriod(), Landscape::SupplyTempPeriod(), and CfgFloat::value().

Referenced by DoFirst().

SetUnsetBreedingSeason()

void Newt_Population_Manager::SetUnsetBreedingSeason ( )

protected

Controls when it is breeding season

TheAOROutputProbe()

void Newt_Population_Manager::TheAOROutputProbe ( )

virtual

Special output functionality.

Reimplemented from Population_Manager.

                                                {
    m_AOR_Probe->DoProbe(tton_Female);
}

References AOR_Probe::DoProbe(), Population_Manager::m_AOR_Probe, and tton_Female.

Member Data Documentation

m_BreedingSeasonFlag

int Newt_Population_Manager::m_BreedingSeasonFlag

protected

Set to 0 when it is newt breeding season, then records the number of days after.

Referenced by DoFirst(), IsBreedingSeason(), and Newt_Population_Manager().

m_NewtAdultProdStats

SimpleStatistics Newt_Population_Manager::m_NewtAdultProdStats

protected

A class for holding the stats on newt adult production.

Referenced by OutputMetamorphosisStats(), and RecordAdultProduction().

m_NewtEgg_DDTempRate

double Newt_Population_Manager::m_NewtEgg_DDTempRate[31]

protected

An array to hold a precalulated day-degree rate transformation for egg development.

Referenced by GetEggDDRateTransformation(), and Newt_Population_Manager().

m_NewtEggProdStats

SimpleStatistics Newt_Population_Manager::m_NewtEggProdStats

protected

A class for holding the stats on newt egg production.

Referenced by OutputMetamorphosisStats(), and RecordEggProduction().

m_NewtMetamorphosisStats

SimpleStatistics Newt_Population_Manager::m_NewtMetamorphosisStats

protected

A class for holding the stats on newt metamorphosis development times.

Referenced by OutputMetamorphosisStats(), and RecordMetamorphosis().

---

The documentation for this class was generated from the following files:

• /builds/a1mass/almass_stable_oddox/Newt/Newt_Population_Manager.h
• /builds/a1mass/almass_stable_oddox/Newt/Newt_Population_Manager.cpp